/*-------------------------------------------------------------------------
 *
 * hmac_openssl.c
 *	  使用 OpenSSL 实现 HMAC。
 *
 * 仅在代码编译时支持 OpenSSL 时使用。
 *
 * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *	  src/common/hmac_openssl.c
 *
 *-------------------------------------------------------------------------
 */

#ifndef FRONTEND
#include "postgres.h"
#else
#include "postgres_fe.h"
#endif


#include <openssl/err.h>
#include <openssl/hmac.h>

#include "common/hmac.h"
#include "common/md5.h"
#include "common/sha1.h"
#include "common/sha2.h"
#ifndef FRONTEND
#include "utils/memutils.h"
#include "utils/resowner.h"
#include "utils/resowner_private.h"
#endif

/*
 * 在后台，如果需要，为resowner清理处理使用TopMemoryContext中的分配。
 * 对于已知HMAC_CTX的OpenSSL版本，只需使用palloc()。在前台，使用malloc以便能够将
 * 失败状态返回给调用者。
 */
#ifndef FRONTEND
#ifdef HAVE_HMAC_CTX_NEW
#define ALLOC(size) MemoryContextAlloc(TopMemoryContext, size)
#else
#define ALLOC(size) palloc(size)
#endif
#define FREE(ptr) pfree(ptr)
#else							/* FRONTEND */
#define ALLOC(size) malloc(size)
#define FREE(ptr) free(ptr)
#endif							/* FRONTEND */

/* 错误状态集 */
typedef enum pg_hmac_errno
{
	PG_HMAC_ERROR_NONE = 0,
	PG_HMAC_ERROR_DEST_LEN,
	PG_HMAC_ERROR_OPENSSL
} pg_hmac_errno;

/* 内部pg_hmac_ctx结构 */
struct pg_hmac_ctx
{
	HMAC_CTX   *hmacctx;
	pg_cryptohash_type type;
	pg_hmac_errno error;
	const char *errreason;

#ifndef FRONTEND
	ResourceOwner resowner;
#endif
};

static const char * fc_SSLerrmessage(unsigned long fc_ecode)
{
	if (fc_ecode == 0)
		return NULL;

	/*
	 * 这可能返回 NULL，但如果是这种情况，我们将退回到默认错误路径。
	 */
	return ERR_reason_error_string(fc_ecode);
}

/*
 * pg_hmac_create
 *
 * 分配一个哈希上下文。在OOM情况下失败时返回NULL。后台发出错误，而不返回。
 */
pg_hmac_ctx *
pg_hmac_create(pg_cryptohash_type fc_type)
{
	pg_hmac_ctx *fc_ctx;

	fc_ctx = ALLOC(sizeof(pg_hmac_ctx));
	if (fc_ctx == NULL)
		return NULL;
	memset(fc_ctx, 0, sizeof(pg_hmac_ctx));

	fc_ctx->type = fc_type;
	fc_ctx->error = PG_HMAC_ERROR_NONE;
	fc_ctx->errreason = NULL;


	/*
	 * 初始化处理为 OpenSSL 分配正确类型的工作。
	 * 还确保没有来自先前运行的未处理错误在队列中。
	 */
	ERR_clear_error();
#ifdef HAVE_HMAC_CTX_NEW
#ifndef FRONTEND
	ResourceOwnerEnlargeHMAC(CurrentResourceOwner);
#endif
	fc_ctx->hmacctx = HMAC_CTX_new();
#else
	fc_ctx->hmacctx = ALLOC(sizeof(HMAC_CTX));
#endif

	if (fc_ctx->hmacctx == NULL)
	{
		explicit_bzero(fc_ctx, sizeof(pg_hmac_ctx));
		FREE(fc_ctx);
#ifndef FRONTEND
		ereport(ERROR,
				(errcode(ERRCODE_OUT_OF_MEMORY),
				 errmsg("out of memory")));
#endif
		return NULL;
	}

#ifdef HAVE_HMAC_CTX_NEW
#ifndef FRONTEND
	fc_ctx->resowner = CurrentResourceOwner;
	ResourceOwnerRememberHMAC(CurrentResourceOwner, PointerGetDatum(fc_ctx));
#endif
#else
	memset(fc_ctx->hmacctx, 0, sizeof(HMAC_CTX));
#endif							/* HAVE_HMAC_CTX_NEW */

	return fc_ctx;
}

/*
 * pg_hmac_init
 *
 * 初始化HMAC上下文。成功时返回0，失败时返回-1。
 */
int pg_hmac_init(pg_hmac_ctx *fc_ctx, const uint8 *fc_key, size_t fc_len)
{
	int			fc_status = 0;

	if (fc_ctx == NULL)
		return -1;

	switch (fc_ctx->type)
	{
		case PG_MD5:
			fc_status = HMAC_Init_ex(fc_ctx->hmacctx, fc_key, fc_len, EVP_md5(), NULL);
			break;
		case PG_SHA1:
			fc_status = HMAC_Init_ex(fc_ctx->hmacctx, fc_key, fc_len, EVP_sha1(), NULL);
			break;
		case PG_SHA224:
			fc_status = HMAC_Init_ex(fc_ctx->hmacctx, fc_key, fc_len, EVP_sha224(), NULL);
			break;
		case PG_SHA256:
			fc_status = HMAC_Init_ex(fc_ctx->hmacctx, fc_key, fc_len, EVP_sha256(), NULL);
			break;
		case PG_SHA384:
			fc_status = HMAC_Init_ex(fc_ctx->hmacctx, fc_key, fc_len, EVP_sha384(), NULL);
			break;
		case PG_SHA512:
			fc_status = HMAC_Init_ex(fc_ctx->hmacctx, fc_key, fc_len, EVP_sha512(), NULL);
			break;
#ifdef FDDGM
		case PG_SM3:
			fc_status = HMAC_Init_ex(fc_ctx->hmacctx, fc_key, fc_len, EVP_sm3(), NULL);
			break;
#endif
	}

	/* OpenSSL 内部成功时返回 1，失败时返回 0 */
	if (fc_status <= 0)
	{
		fc_ctx->errreason = fc_SSLerrmessage(ERR_get_error());
		fc_ctx->error = PG_HMAC_ERROR_OPENSSL;
		return -1;
	}

	return 0;
}

/*
 * pg_hmac_update
 *
 * 更新HMAC上下文。成功时返回0，失败时返回-1。
 */
int pg_hmac_update(pg_hmac_ctx *fc_ctx, const uint8 *fc_data, size_t fc_len)
{
	int			fc_status = 0;

	if (fc_ctx == NULL)
		return -1;

	fc_status = HMAC_Update(fc_ctx->hmacctx, fc_data, fc_len);

	/* OpenSSL 内部成功时返回 1，失败时返回 0 */
	if (fc_status <= 0)
	{
		fc_ctx->errreason = fc_SSLerrmessage(ERR_get_error());
		fc_ctx->error = PG_HMAC_ERROR_OPENSSL;
		return -1;
	}
	return 0;
}

/*
 * pg_hmac_final
 *
 * 最终确定HMAC上下文。成功时返回0，失败时返回-1。
 */
int pg_hmac_final(pg_hmac_ctx *fc_ctx, uint8 *fc_dest, size_t fc_len)
{
	int			fc_status = 0;
	uint32		fc_outlen;

	if (fc_ctx == NULL)
		return -1;

	switch (fc_ctx->type)
	{
		case PG_MD5:
			if (fc_len < MD5_DIGEST_LENGTH)
			{
				fc_ctx->error = PG_HMAC_ERROR_DEST_LEN;
				return -1;
			}
			break;
		case PG_SHA1:
			if (fc_len < SHA1_DIGEST_LENGTH)
			{
				fc_ctx->error = PG_HMAC_ERROR_DEST_LEN;
				return -1;
			}
			break;
		case PG_SHA224:
			if (fc_len < PG_SHA224_DIGEST_LENGTH)
			{
				fc_ctx->error = PG_HMAC_ERROR_DEST_LEN;
				return -1;
			}
			break;
		case PG_SHA256:
			if (fc_len < PG_SHA256_DIGEST_LENGTH)
			{
				fc_ctx->error = PG_HMAC_ERROR_DEST_LEN;
				return -1;
			}
			break;
		case PG_SHA384:
			if (fc_len < PG_SHA384_DIGEST_LENGTH)
			{
				fc_ctx->error = PG_HMAC_ERROR_DEST_LEN;
				return -1;
			}
			break;
		case PG_SHA512:
			if (fc_len < PG_SHA512_DIGEST_LENGTH)
			{
				fc_ctx->error = PG_HMAC_ERROR_DEST_LEN;
				return -1;
			}
			break;
#ifdef FDDGM
		case PG_SM3:
			if (fc_len < PG_SM3_DIGEST_LENGTH)
			{
				fc_ctx->error = PG_HMAC_ERROR_DEST_LEN;
				return -1;
			}
			break;
#endif
	}

	fc_status = HMAC_Final(fc_ctx->hmacctx, fc_dest, &fc_outlen);

	/* OpenSSL 内部成功时返回 1，失败时返回 0 */
	if (fc_status <= 0)
	{
		fc_ctx->errreason = fc_SSLerrmessage(ERR_get_error());
		fc_ctx->error = PG_HMAC_ERROR_OPENSSL;
		return -1;
	}
	return 0;
}

/*
 * pg_hmac_free
 *
 * 释放HMAC上下文。
 */
void pg_hmac_free(pg_hmac_ctx *fc_ctx)
{
	if (fc_ctx == NULL)
		return;

#ifdef HAVE_HMAC_CTX_FREE
	HMAC_CTX_free(fc_ctx->hmacctx);
#ifndef FRONTEND
	ResourceOwnerForgetHMAC(fc_ctx->resowner, PointerGetDatum(fc_ctx));
#endif
#else
	explicit_bzero(fc_ctx->hmacctx, sizeof(HMAC_CTX));
	FREE(fc_ctx->hmacctx);
#endif

	explicit_bzero(fc_ctx, sizeof(pg_hmac_ctx));
	FREE(fc_ctx);
}

/*
 * pg_hmac_error
 *
 * 返回一个静态字符串，提供有关HMAC计算过程中发生错误的详细信息。
 */
const char * pg_hmac_error(pg_hmac_ctx *fc_ctx)
{
	if (fc_ctx == NULL)
		return _("out of memory");

	/*
	 * 如果提供了原因，则依赖于它，否则退回到设置的任何错误代码。
	 */
	if (fc_ctx->errreason)
		return fc_ctx->errreason;

	switch (fc_ctx->error)
	{
		case PG_HMAC_ERROR_NONE:
			return _("success");
		case PG_HMAC_ERROR_DEST_LEN:
			return _("destination buffer too small");
		case PG_HMAC_ERROR_OPENSSL:
			return _("OpenSSL failure");
	}

	Assert(false);				/* 无法到达 */
	return _("success");
}
